
//fun main() {
//    var a: String = "abc"
////    a = null // Null cannot be a value of a non-null type 'String'.
//
////    val l = a.length
////    println(l)
//
//    var b: String? = "abc"
//    b = null
//
//    val l: Int = if (b != null) b.length else -1
//    print(l)
//
////    Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type 'Nothing?'
////    val l = b.length
////    print(l)
//
////}
//
//fun main() {
//    var b: String? = "kotlin"
//
//    if (b != null && b.length > 0) {
//        println("String length: ${b.length}")
//    }
//    else {
//        println("Empty")
//    }
//
////    b = null
//    val res = b?.length
//
//    println(res)
//}

fun foo(s: String?): String? {

    s?.length ?: return null // ?: EIvis 运算符

    return s
}

//fun Any?.toString(): String {
//    if (this == null) return "null"
//
//    return toString()
//}

//fun Any?.toString(): String {
//    return this?.toString() ?: "null"
//}

//fun main() {
////    var s: String? = null
////
////    print(s?.length ?: 0)
////
////    s = "acbc"
////
////    print("\n${s?.length ?: 0}")
//
////    println(null)
////    println("abc")
//
//    var b: String? = "Kotlin"
//    println(b.toString())
////    val l = b!!.length
////    println(l)
//
//
//    b = null
//
//    println(b.toString())
//    println(b?.toString())
//
////    println(b.toString())
////    println(b?.toString())
////    val l2 = b!!.length // NullPointerException
//}

//fun main() {
//    var b: String? = null
//
//    val result1 = b.toString()
//    println(result1)
//    println(result1 is String) // String
//
//    val result2 = b?.toString()
//    println(result2)
//    println(result2 is String?) // null
//
//    // result1 是 "null" 字符串
//    // result2 是 null -- 空值
//}
//
//fun main() {
//    var b: String? = "hello"
//
//    // toString() 内部做了空值检查
//
//    val result1 = b.toString() // 不管 b 是不是 null 都可以调用 toString()，非空返回字符串本身，null 返回 "null"
//    println(result1)
//    println(result1 is String)
//
//    val result2 = b?.toString() // b 是字符串才调用 toString()，返回字符串本身；否则返回 null -- 空值
//    println(result2)
//    println(result2 is String?)
//
//    println(b?.length)
//    b = null
//    println(b?.length)
//}

//fun main() {
//    val numbers = mutableListOf("one", "two", "three", "four", "five")
////    val temp = listOf("one", "two", "three")
////
////    val resultLists = temp.map{ it.length }.filter { it > 3 }
////    print(resultLists)
//
//    numbers.map{ it.length }.filter { it > 3 }.let {
//        println(it) // 此处 it 为某个字符串的 length 值
//    }
//
//}

//fun main() {
//    val str: String? = "Hello"
//
//    val length = str?.let {
//        println("let() called on $it")
////        processNonNullString(it)
//        it.length
//    }
//
//    println(length)
//}


//fun main() {
//    val numbers = listOf("one", "two", "three", "four", "five")
//
//    numbers.filter { it.length > 3 }. let {
//        println(it)
//    }
//
//    numbers.map { it }.filter{ it.length > 3 }. let {
//        println(it)
//    }
//}

//class User(val name: String, val age: Int);
//
//fun main() {
//    // 集合插入、删除操作还不知道呢！！
//    val users = listOf<User>(
//        User("Bob", 18),
//        User("Mike", 20),
//        User("Alice", 19),
//        User("Tom", 23)
//    );
//
////    users.filter{ it.age > 18 }.let { println(it) }
////    val names = users.map{ it.name }
////    println(names)
//
//    // .filter{}.map{} 筛选后再变换
//    // .map{}.filter{} 变换后再筛选
//
//    users.filter{ it.age > 18 }.map{ it.name }.let{ adultNames ->
//        println("adult size: ${adultNames.size}")
//        println(adultNames)
//    }
//
////    users.filter{ it.age > 18 }.map{ it.name }.let{ println(it) }
////    println(adultNames)
//}


// Kotlin 标准库源码简化
//fun <T, R> T.let(block: (T) -> R): R {
//    // block 是传入的 lambda 表达式，把当前对象 T 作为参数传递给 block，返回 R 类型结果
//    return block(this)
//}

fun <T, R> T.let(block: (T) -> R): R {
    return block(this)
}

class User(val name: String, val age: Int)

fun processUserList(users: List<User>): List<String> {
    // 过滤成年 -> 提取名字 -> 转换为大写返回
    return users.filter{ it.age >= 18 }
        .map{ it.name }
        .let { adultNames ->
            println("成年名字数量：${adultNames.size}")
            adultNames.map { it.uppercase() }

            // 不要 return 错位置
//            return adultNames.map { it.uppercase() }
        }
}

fun main() {
//    val numbers = mutableListOf("one", "two", "three", "four", "five")
//
//    numbers.map{ it.length }.filter{ it > 3 }.let{
//        println(it)
//        println(it.sum())
//    }

    // ?.let 安全处理可空对象 -- 对象非空才执行逻辑，代替 if (... != null) {}
    val str: String? = "hello"

    val length = str?.let{str -> // 自定义参数名代替 it，在某些场景下可以提升代码可读性
        println("let() called on $str")
        str.length
    }

    println("length is $length")

    // 如果 let 的 lambda 表达式中只有一个函数调用，可以使用 ::函数名 代替 lambda，让代码更简洁
    str?.let(::println)
//    str?.let{
//        println(it)
//    }


}
